La Diferencia Entre `dup` y `clone` en Ruby

Ruby es un lenguaje de programación muy versátil y poderoso, conocido por su simplicidad y elegancia. Uno de los conceptos fundamentales en Ruby es la manipulación de objetos, y dentro de este contexto, las operaciones de duplicación de objetos son esenciales. En Ruby, existen dos métodos principales para duplicar objetos: `dup` y `clone`. Aunque ambos métodos pueden parecer similares a primera vista, tienen diferencias clave que es importante entender. En este artículo, exploraremos en profundidad las diferencias entre `dup` y `clone`, así como sus usos y ejemplos prácticos.

¿Qué es `dup`?

El método `dup` se utiliza para crear una copia superficial de un objeto. Esto significa que se crea un nuevo objeto que tiene el mismo estado que el objeto original, pero no comparte la misma referencia en memoria. Sin embargo, es importante tener en cuenta que si el objeto original contiene referencias a otros objetos (como en el caso de arrays o hashes), esas referencias no se duplican; en su lugar, se copian las referencias, lo que significa que los objetos internos seguirán siendo los mismos.

Ejemplo de `dup`

Veamos un ejemplo simple para ilustrar cómo funciona `dup`:

# Definimos una clase simple
class Persona
  attr_accessor :nombre, :edad

  def initialize(nombre, edad)
    @nombre = nombre
    @edad = edad
  end
end

# Creamos un objeto de la clase Persona
persona1 = Persona.new("Juan", 30)

# Usamos dup para crear una copia
persona2 = persona1.dup

# Modificamos la copia
persona2.nombre = "Pedro"

# Mostramos los resultados
puts persona1.nombre  # Salida: Juan
puts persona2.nombre  # Salida: Pedro

En este ejemplo, `persona1` y `persona2` son dos objetos diferentes. Cambiar el nombre de `persona2` no afecta a `persona1`, lo que demuestra que `dup` crea una copia superficial.

¿Qué es `clone`?

El método `clone`, por otro lado, también crea una copia del objeto, pero con una diferencia importante: `clone` copia tanto el estado del objeto como su estado de congelación y sus variables de instancia. Esto significa que si el objeto original está congelado, la copia también estará congelada. Además, `clone` también copia los singleton methods (métodos específicos de un objeto) del objeto original.

Ejemplo de `clone`

Veamos un ejemplo para entender mejor cómo funciona `clone`:

# Definimos una clase simple
class Vehiculo
  attr_accessor :modelo, :año

  def initialize(modelo, año)
    @modelo = modelo
    @año = año
  end
end

# Creamos un objeto de la clase Vehiculo
vehiculo1 = Vehiculo.new("Toyota", 2020)

# Usamos clone para crear una copia
vehiculo2 = vehiculo1.clone

# Modificamos la copia
vehiculo2.modelo = "Honda"

# Mostramos los resultados
puts vehiculo1.modelo  # Salida: Toyota
puts vehiculo2.modelo  # Salida: Honda

Al igual que con `dup`, `vehiculo1` y `vehiculo2` son objetos diferentes, y cambiar el modelo de `vehiculo2` no afecta a `vehiculo1`.

Diferencias Clave Entre `dup` y `clone`

A continuación, se presentan las diferencias clave entre `dup` y `clone`:

Copia de Congelación: `dup` no copia el estado de congelación del objeto original, mientras que `clone` sí lo hace.
Copia de Métodos Singleton: `dup` no copia los métodos singleton, mientras que `clone` sí lo hace.
Uso de Variables de Instancia: Ambos métodos copian las variables de instancia, pero `clone` también copia el estado de congelación.

Cuándo Usar `dup` y Cuándo Usar `clone`

La elección entre `dup` y `clone` depende del contexto y de lo que necesites lograr. Aquí hay algunas pautas para ayudarte a decidir:

Usa `dup`: Cuando solo necesitas una copia superficial del objeto y no te importa el estado de congelación o los métodos singleton.
Usa `clone`: Cuando necesitas una copia que mantenga el estado de congelación del objeto original o cuando necesitas copiar métodos singleton.

Ejemplo Práctico: Comparación de `dup` y `clone`

Para ilustrar aún más las diferencias, consideremos un ejemplo práctico que utiliza ambos métodos:

# Definimos una clase con un método singleton
class CuentaBancaria
  attr_accessor :saldo

  def initialize(saldo)
    @saldo = saldo
  end

  def self.interes
    0.05
  end

  def saldo_con_interes
    @saldo * (1 + self.class.interes)
  end
end

# Creamos un objeto de la clase CuentaBancaria
cuenta1 = CuentaBancaria.new(1000)

# Usamos dup para crear una copia
cuenta2 = cuenta1.dup

# Usamos clone para crear otra copia
cuenta3 = cuenta1.clone

# Modificamos el saldo de la copia
cuenta2.saldo = 500

# Mostramos los resultados
puts cuenta1.saldo  # Salida: 1000
puts cuenta2.saldo  # Salida: 500
puts cuenta3.saldo  # Salida: 1000

# Llamamos al método de saldo con interés
puts cuenta1.saldo_con_interes  # Salida: 1050.0
puts cuenta2.saldo_con_interes  # Salida: 525.0
puts cuenta3.saldo_con_interes  # Salida: 1050.0

En este ejemplo, `cuenta1`, `cuenta2` y `cuenta3` son objetos diferentes. Cambiar el saldo de `cuenta2` no afecta a `cuenta1` ni a `cuenta3`. Sin embargo, si `cuenta1` tuviera métodos singleton, solo `cuenta3` tendría acceso a esos métodos, ya que `dup` no los copia.

Conclusión

En resumen, tanto `dup` como `clone` son métodos útiles en Ruby para crear copias de objetos, pero tienen diferencias significativas que pueden afectar el comportamiento de tu código. Al entender estas diferencias, puedes tomar decisiones más informadas sobre qué método utilizar en función de tus necesidades específicas. Recuerda que `dup` es ideal para copias superficiales, mientras que `clone` es más adecuado cuando necesitas mantener el estado de congelación o los métodos singleton. ¡Feliz codificación en Ruby!